﻿#define _CRT_SECURE_NO_WARNINGS 1
#include<iostream>
using namespace std;

//实现⼀个不能被继承的类

 //1.⽗类的构造函数私有，⼦类的构成必须调⽤⽗类的构造函数，但是⽗类的构成函数私有化以后，⼦类看不⻅就不能调⽤了，那么⼦类就⽆法实例化出对象
//class Base
//{
//public:
//	void func() { cout << "Base::func" << endl; }
//protected:
//	int a = 1;
//private:
//	Base();//私有化
//};
//
//class Derive :public Base
//{
//public:
//	void func1() { cout << "Derive::func1()" << endl; }
//};
//int main()
//{
//	//Derive d;//报错
//	return 0;
//}

//2.final修改⽗类，⼦类就不能继承了。
//class Base final
//{
//public:
//	void func5() { cout << "Base::func5" << endl; }
//protected:
//	int a = 1;
//private:
//	// C++98的⽅法
//	/*Base()
//	{}*/
//};
//class Derive :public Base
//{
//	void func4() { cout << "Derive::func4" << endl; }
//protected:
//	int b = 2;
//};
//int main()
//{
//	Base b;
//	Derive d;
//	return 0;
//}


//继承和友元
//友元关系不能继承，也就是说⽗类友元不能访问⼦类私有和保护成员 
//class Student;
//class Person
//{
//public:
//	friend void Display(const Person& p, const Student& s);//Display是父类的友元
//protected:
//	string _name; // 姓名
//};
//class Student : public Person
//{
//	friend void Display(const Person& p, const Student& s);// 解决⽅案：Display也变成Student 的友元即可
//protected:
//	int _stuNum; // 学号
//};
//void Display(const Person& p, const Student& s)
//{
//	cout << p._name << endl;
//	cout << s._stuNum << endl; //⽗类友元不能访问⼦类私有和保护成员
//}
//int main()
//{
//	Person p;
//	Student s;
//	// 编译报错：error C2248: “Student::_stuNum”: ⽆法访问 protected 成员
//	// 解决⽅案：Display也变成Student 的友元即可
//	Display(p, s);
//	return 0;
//}


//继承与静态成员
//⽗类定义了static静态成员，则整个继承体系⾥⾯只有⼀个这样的成员。⽆论派⽣出多少个⼦类，都只有⼀个static成员实例。
//class Person
//{
//public:
//	string _name;
//	static int _count;
//};
//int Person::_count = 0;
//
//class Student : public Person
//{
//protected:
//	int _stuNum;
//};
//int main()
//{
//	Person p;
//	Student s;
//	// 这⾥的运⾏结果可以看到⾮静态成员_name的地址是不⼀样的
//	// 说明⼦类继承下来了，⽗\⼦类对象各有⼀份
//	cout << &p._name << endl;
//	cout << &s._name << endl;
//	// 这⾥的运⾏结果可以看到静态成员_count的地址是⼀样的
//	// 说明⼦类和⽗类共⽤同⼀份静态成员
//	cout << &p._count << endl;
//	cout << &s._count << endl;
//	// 公有的情况下，⽗\⼦类指定类域都可以访问静态成员
//	cout << Person::_count << endl;
//	cout << Student::_count << endl;
//	return 0;
//}


//单继承:：⼀个⼦类只有⼀个直接⽗类时称这个继承关系为单继承
//多继承：⼀个⼦类有两个或以上直接⽗类时称这个继承关系为多继承
//菱形继承：有数据冗余(浪费)和⼆义性(歧义)的问题(解决需要用virtual)
//有多继承一定有菱形继承(尽量不用)
//class Person
//{
//public:
//	string _name; // 姓名
//};
//// 使⽤虚继承Person类
//class Student : virtual public Person//谁产生数据冗余谁加virtual
//{
//protected:
//	int _num; //学号
//};
//// 使⽤虚继承Person类
//class Teacher : virtual public Person//谁产生数据冗余谁加virtual
//{
//protected:
//	int _id; // 职⼯编号
//};
//// 教授助理
//class Assistant : public Student, public Teacher
//{
//protected:
//	string _majorCourse; // 主修课程
//};
//int main()
//{
//	// 使⽤虚继承，可以解决数据冗余和⼆义性
//	Assistant a;
//	a._name = "peter";
//	return 0;
//}

//单继承随便用
//多继承不涉及菱形继承可以用



//继承和组合
//public继承是⼀种is - a的关系。也就是说每个⼦类对象都是⼀个⽗类对象。
//组合是⼀种has - a的关系。假设B组合了A，每个B对象中都有⼀个A对象。

